package java8.com.atguigu.lambda;

import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * 一、构造器引用
 * 1.格式： 类名 :: new
 * 2.要求：函数式接口中抽象方法的形参列表与构造器形参列表一致（类型相同，个数相同），
 *        同时，抽象方法的返回值类型即为构造器所属的类的类型。
 *
 *
 * 二、数组引用
 *面向对象的语言叫方法
 *
 * 面向过程的语言叫函数
 *
 * 在java中没有函数这么一说，只有方法一说。实际上方法就是函数，函数就是方法，只是在不同的语言不同的称呼而已。
 *
 *  
 *
 * 一句话告诉你如何区分函数与方法：函数是大家的函数，方法是类的方法。
 * 如何区分一个ITer是设计师还是码工。
 * 看看他是在调别人的库，还是自己写出JAR包跟别人分享。
 * 感觉差的不是一个级别而已啊。
 * 一个东西，用对象调用的叫方法，直接调函数名的叫函数。
 * c语言等语言里叫函数，面向对象编程，函数写到类里边就叫做方法，函数可以直接调用，对象中的方法一般都有指针this指向它，但是有时一些方法实在不需要写到类里边，所以面向对象的语言有了静态方法，不过这个概念没必要纠结，用的多了自然就明白啦
 * 函数Function, 过程Procedure, 方法Method，你可以简单把他们当成同一个概念：都是由若干语句组成的一个可执行代码体。
 * 函数：Function（面向过程语言教程的英文原版，是否有一个把Function翻译为Method的？）
 * 方法：Method（只有不地道的面向对象语言教程才会把Method叫做Function）
 * 意思一样的，可能就是方法偏重于类，也就是面向对象设计的，注重每个函数的功能所以叫方法；而函数偏重于面向过程，有可能是功能描述也有能不是，两者都有是看编程者自己怎么看的
 *
 * Created by shkstart on 2017/8/29 0029.
 */
public class ConstructorRefTest {
    @Test
    public void test7(){
        // Optional
        Optional<String> optional = Optional.ofNullable("sss");
        boolean present = optional.isPresent();
        String s = optional.orElse("0");

        if(optional.isPresent()){ //是否存在
            //.isPresent()一般与.get()方法合用，当optional中存在course时，optional.isPresent()值为true，通过get（）方法返回对象。
            optional.get();
        }
    }

    @Test
    public void test6(){
        // 方法引用,当要传入的lambda体的操作, 已经有实现的方法时,使用方法引用,
        Function<String, Integer> stringToInteger = Integer::parseInt;
        Integer apply = stringToInteger.apply("123");
    }

    @Test
    public void test5(){
        // 注意点 : 参数不用写类型 ,一行不用写大括号 , 一行不用写返回值
        Arrays.asList("a","b","c").forEach(e -> System.out.println(e));
        List<String> strings = Arrays.asList("a", "b", "d");
        Arrays.asList( "a", "b", "d" ).sort( ( e1, e2 ) -> {
            int result = e1.compareTo( e2 );
            return result;
        } );

        Runnable r = () ->System.out.println("Hello World!");
        Runnable r2 = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello World!");
            }
        };

    }


    @Test
    public void test4(){
        Function<Integer,String[]> func1 = (length) -> new String[length];
        String[] arr = func1.apply(10);
        System.out.println(arr.length);

        System.out.println("**********");
        
        Function<Integer,String[]> func12 = String[] ::new;
        
    }

    @Test
    public void test3(){
        BiFunction<Integer,String,Employee> func1 = (id,name) -> new Employee(id,name);
        Employee emp = func1.apply(10, "Jim");
        System.out.println(emp);

        System.out.println("**********");

        BiFunction<Integer,String,Employee> func2 =  Employee ::new;
    }
    @Test
    public void test2(){
        Function<Integer,Employee> func1 = (id) -> new Employee(id);
        Employee emp1 = func1.apply(12);
        System.out.println(emp1);

        System.out.println("**********");

        Function<Integer,Employee> func2 = Employee::new;
    }
    @Test
    public void test1(){
        Supplier<Employee> sup = () -> new Employee();
        Employee emp = sup.get();
        System.out.println(emp);

        System.out.println("**********");

        Supplier<Employee> sup1 = Employee :: new;
    }

    public static void main(String[] args) {

    }
}
